home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Networking / GetEnetAddrDirect.ppc / GetEnetAddrDirect.c next >
Encoding:
C/C++ Source or Header  |  2000-09-28  |  11.6 KB  |  441 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        GetEnetAddrDirect.c
  3.  
  4.     Contains:    This is a sample program to obtain the ethernet address from a Power Mac using
  5.                 1. direct access to the ROM for the 61/71/8100 Power Macs, or by accessing the
  6.                 Name Registry for PCI based systems. This means that the the address can be 
  7.                 accessed without Open Transport being available, or without having to open the
  8.                 Ethernet device driver.
  9.  
  10.                 2. use OpenTransport to display the ethernet address for all ethernet devices
  11.                 that are detected.  For this method to work, the program opens a connection over
  12.                 the found ethernet port. If the openConnection call works, then we can use the 
  13.                 OT APIs to obtain the ethernet address.
  14.  
  15.                 For the earlier Power Macs, 6100/ 7100/8100, the Burned In Address is found in 
  16.                 ROM at address 0x50f08000.  One must read every 16 bytes for each of the 6
  17.                 bytes that make up the address. That is you'll need to 
  18.                 read address 50f08000, 50f08010, 50f08020, 50f08030, 50f08040, 
  19.                 and  50f08050.  The found address is byte swapped. which means
  20.  
  21.                 10 00 E0 2B 06 AF, which if you bit invert each byte becomes
  22.  
  23.                 08 00 07 D4 60 F5.
  24.  
  25.                 For PCI Power Macs, the burned in address is generally in 
  26.                 the Name Registry, however, the name of the entry is vendor 
  27.                 specified.  For the 72/73/75/76/85/86/95/9600 Power Macs, look at the
  28.                 "local-mac-address" entry. For the PCI Power Macs which use the Comm Slot2
  29.                 card, look at the "ASNT,ethernet-address" entry for a pointer to where the
  30.                 ethernet address is stored.
  31.  
  32.                 The one set of Power Macs, that this program does not demonstrate how to access
  33.                 using the direct means are the 52/53/62/6300 systems which use the original
  34.                 CommSlot Ethernet card and which can also use the PDS slot LC style ethernet
  35.                 card
  36.  
  37.     Written by: Rich Kubota    
  38.  
  39.     Copyright:    Copyright © 1999 by Apple Computer, Inc., All Rights Reserved.
  40.  
  41.                 You may incorporate this Apple sample source code into your program(s) without
  42.                 restriction. This Apple sample source code has been provided "AS IS" and the
  43.                 responsibility for its operation is yours. You are not permitted to redistribute
  44.                 this Apple sample source code as "Apple sample source code" after having made
  45.                 changes. If you're going to re-distribute the source, we require that you make
  46.                 it clear in the source that the code was descended from Apple sample source
  47.                 code, but that you've made changes.
  48.  
  49.     Change History (most recent first):
  50.                 7/22/1999    Karl Groethe    Updated for Metrowerks Codewarror Pro 2.1
  51.                 
  52.  
  53. */
  54. #include <MacTypes.h>
  55. #include <Gestalt.h>
  56. #include <Errors.h>
  57. #include <NameRegistry.h>
  58. #include <stdio.h>
  59. #include <Strings.h>
  60. #include <OpenTransport.h>
  61. #include <OpenTptLinks.h>
  62. #include <OpenTptConfig.h>
  63.  
  64.  
  65. enum {
  66.     kUnsupported         = 0,
  67.     kPDMMachine            = 1,
  68.     kPCIMachine            = 2,
  69.     kCommSlotMachine    = 3,
  70.     kPCIComm2Machine     = 4
  71. };
  72.  
  73. enum {
  74.     kPDMEnetROMBase    = 0x50f08000
  75. };
  76.  
  77. enum {
  78.     gestaltPowerBookG3SeriesFSTN     = 314,
  79.     gestaltiMac                        = 406
  80. };
  81.  
  82. struct Address8022
  83. {
  84.     OTAddressType    fAddrFamily;
  85.     UInt8            fHWAddr[k48BitAddrLength];
  86.     UInt16            fSAP;
  87.     UInt8            fSNAP[k8022SNAPLength];
  88. };
  89. typedef struct Address8022 Address8022;
  90.  
  91. UInt32         DoesCPUHaveBuiltInEthernet(void);
  92. UInt8        ByteSwapValue(UInt8 val);
  93. OSStatus     GetPDMBuiltInEnetAddr(UInt8 *enetaddr);
  94. OSStatus     GetPCIBuiltInEnetAddr(UInt8 *enetaddr);
  95. OSStatus     GetPCIComm2EnetAddr(UInt8 *enetaddr);
  96. void        DisplayEnetAddr(UInt8 *enetaddr);
  97. void        DisplayBurnedInAddress(void);
  98. void         DisplayOTEthernetAddresses(void);
  99.  
  100.  
  101. UInt32 DoesCPUHaveBuiltInEthernet(void)
  102. {
  103.     long        response;
  104.     OSStatus    err;
  105.     UInt32        result = kUnsupported;
  106.     
  107.     err = Gestalt(gestaltMachineType, &response);
  108.     switch (response)
  109.     {
  110.         case gestaltPowerMac8100_120:
  111.         case gestaltAWS9150_80:
  112.         case gestaltPowerMac8100_110:
  113.         case gestaltPowerMac7100_80:
  114.         case gestaltPowerMac8100_100:
  115.         case gestaltAWS9150_120:
  116.         case gestaltPowerMac8100_80:
  117.         case gestaltPowerMac6100_60:
  118.         case gestaltPowerMac6100_66:
  119.         case gestaltPowerMac7100_66:
  120.             result = kPDMMachine;
  121.             break;
  122.         
  123.         case gestaltPowerMac9500:
  124.         case gestaltPowerMac7500:
  125.         case gestaltPowerMac8500:
  126.         case gestaltPowerBook3400:
  127.         case gestaltPowerBookG3:
  128.         case gestaltPowerMac7200:
  129.         case gestaltPowerMac7300:
  130.         case gestaltPowerBookG3Series:
  131.         case gestaltPowerBookG3SeriesFSTN:
  132.         case gestaltPowerMacG3:
  133.         case gestaltiMac:
  134.             result = kPCIMachine;
  135.             break;
  136.             
  137.         case gestaltPowerMac5200:
  138.         case gestaltPowerMac6200:
  139.             result = kCommSlotMachine;
  140.             break;
  141.             
  142.         case gestaltPowerMac6400:
  143.         case gestaltPowerMac5400:
  144.         case gestaltPowerMac5500:
  145.         case gestaltPowerMac6500:
  146.         case gestaltPowerMac4400_160:
  147.         case gestaltPowerMac4400:
  148.             result = kPCIComm2Machine;
  149.         
  150.     }
  151.     
  152.     if (response == kUnsupported)
  153.     {
  154.         err = Gestalt(gestaltNameRegistryVersion, (long*) &response);
  155.         if (err == noErr)
  156.             result = kPCIMachine;
  157.     }
  158.     return result;
  159. }
  160.  
  161. UInt8        ByteSwapValue(UInt8 val)
  162. {
  163.     UInt8    result = 0;
  164.     
  165.     if (val & 0x01)
  166.         result |= 0x80;
  167.         
  168.     if (val & 0x02)
  169.         result |= 0x40;
  170.         
  171.     if (val & 0x04)
  172.         result |= 0x20;
  173.         
  174.     if (val & 0x08)
  175.         result |= 0x10;
  176.         
  177.     if (val & 0x10)
  178.         result |= 0x08;
  179.         
  180.     if (val & 0x20)
  181.         result |= 0x04;
  182.         
  183.     if (val & 0x40)
  184.         result |= 0x02;
  185.         
  186.     if (val & 0x80)
  187.         result |= 0x01;
  188.     return result;
  189. }
  190.  
  191. OSStatus     GetPDMBuiltInEnetAddr(UInt8 *enetaddr)
  192. {
  193.     UInt32    i;
  194.     UInt8    *val;
  195.  
  196.     for (i = 0; i < 6; i++)
  197.     {
  198.         val = (UInt8 *)(kPDMEnetROMBase + i * 0x10);
  199.         enetaddr[i] = ByteSwapValue(*val);
  200.     }
  201.     return noErr;
  202. }
  203.  
  204.  
  205. OSStatus     GetPCIBuiltInEnetAddr(UInt8 *enetaddr)
  206. {
  207.     OSStatus                err = noErr;
  208.     RegEntryIter            cookie;
  209.     RegEntryID              theFoundEntry;
  210.     unsigned char              enetAddrStr[32] = "\plocal-mac-address";
  211.     RegCStrEntryNamePtr     enetAddrCStr = p2cstr( enetAddrStr );
  212.     RegEntryIterationOp     iterOp;
  213.     UInt8                    enetAddr[6];
  214.     Boolean                 done = false;
  215.     RegPropertyValueSize    theSize;
  216.     
  217.     err = RegistryEntryIDInit( &theFoundEntry );
  218.     if (err != noErr)
  219.     {
  220.         fprintf(stdout, "RegistryEntryIDInit failed\n");
  221.         return err;
  222.     }
  223.  
  224.     err = RegistryEntryIterateCreate( &cookie );
  225.     if (err != noErr)
  226.     {
  227.         fprintf(stdout, "RegistryEntryIterateCreate failed\n");
  228.         return err;
  229.     }
  230.  
  231.     iterOp = kRegIterDescendants;
  232.  
  233.     err = RegistryEntrySearch( &cookie, iterOp, &theFoundEntry, &done,
  234.                                                        enetAddrCStr, nil, 0);
  235.     
  236.     if (err == noErr)
  237.     {
  238.         theSize = sizeof(enetAddr);;
  239.         err = RegistryPropertyGet(&theFoundEntry, enetAddrCStr, &enetAddr, &theSize );
  240.         if (err == noErr)
  241.             BlockMove(enetAddr, enetaddr, sizeof(enetAddr));
  242.     }
  243.  
  244.     RegistryEntryIterateDispose( &cookie );
  245.  
  246.     return noErr;
  247. }
  248.  
  249. OSStatus     GetPCIComm2EnetAddr(UInt8 *enetaddr)
  250. {
  251.     OSStatus                err = noErr;
  252.     RegEntryIter            cookie;
  253.     RegEntryID              theFoundEntry;
  254.     unsigned char              enetAddrStr[32] = "\pASNT,ethernet-address";
  255.     RegCStrEntryNamePtr     enetAddrCStr = p2cstr( enetAddrStr );
  256.     RegEntryIterationOp     iterOp;
  257.     UInt8                    *enetAddr;
  258.     Boolean                 done = false;
  259.     RegPropertyValueSize    theSize;
  260.     
  261.     err = RegistryEntryIDInit( &theFoundEntry );
  262.     if (err != noErr)
  263.     {
  264.         fprintf(stdout, "RegistryEntryIDInit failed\n");
  265.         return err;
  266.     }
  267.  
  268.     err = RegistryEntryIterateCreate( &cookie );
  269.     if (err != noErr)
  270.     {
  271.         fprintf(stdout, "RegistryEntryIterateCreate failed\n");
  272.         return err;
  273.     }
  274.  
  275.     iterOp = kRegIterDescendants;
  276.  
  277.     err = RegistryEntrySearch( &cookie, iterOp, &theFoundEntry, &done,
  278.                                                        enetAddrCStr, nil, 0);
  279.     
  280.     if (err == noErr)
  281.     {
  282.         theSize = sizeof(enetAddr);;
  283.         err = RegistryPropertyGet(&theFoundEntry, enetAddrCStr, &enetAddr, &theSize );
  284.         if (err == noErr)
  285.             BlockMove(enetAddr, enetaddr, 6);
  286.     }
  287.  
  288.     RegistryEntryIterateDispose( &cookie );
  289.  
  290.     return noErr;
  291. }
  292.  
  293. void        DisplayEnetAddr(UInt8 *enetaddr)
  294. {    
  295.     fprintf(stdout, "%02X.",(int )enetaddr[0]);
  296.     fprintf(stdout, "%02X.",(int )enetaddr[1]);
  297.     fprintf(stdout, "%02X.",(int )enetaddr[2]);
  298.     fprintf(stdout, "%02X.",(int )enetaddr[3]);
  299.     fprintf(stdout, "%02X.",(int )enetaddr[4]);
  300.     fprintf(stdout, "%02X",(int )enetaddr[5]);
  301. }
  302.  
  303. void DisplayBurnedInAddress(void)
  304. {
  305.     OSStatus    err;
  306.     UInt32        cputype;
  307.     UInt8        enetaddr[6];
  308.  
  309.     fprintf(stdout, "First, get the burned-in ethernet address directly from ROM or NameRegistry\n");
  310.     cputype = DoesCPUHaveBuiltInEthernet();
  311.     switch (cputype)
  312.     {
  313.         case kPDMMachine:
  314.             err = GetPDMBuiltInEnetAddr((UInt8*)enetaddr);
  315.             if (err == noErr)
  316.             {
  317.                 fprintf(stdout, "\nBurned-In address for Ethernet Built-In => ");
  318.                 DisplayEnetAddr((UInt8*)&enetaddr);
  319.             }
  320.             break;
  321.         
  322.         case kPCIMachine:
  323.             err = GetPCIBuiltInEnetAddr((UInt8*)enetaddr);
  324.             if (err == noErr)
  325.             {
  326.                 fprintf(stdout, "\nBurned-In address for Ethernet Built-In => ");
  327.                 DisplayEnetAddr((UInt8*)&enetaddr);
  328.             }
  329.             break;
  330.         
  331.         case kCommSlotMachine:
  332.             fprintf(stdout, "\n\nThis is a NuBus based Power Mac which may have a CommSlot Ethernet card");
  333.             fprintf(stdout, "\nmust use Open Transport to obtain the ethernet address");
  334.             break;
  335.         
  336.         case kPCIComm2Machine:
  337.             fprintf(stdout, "\n\nThis is a PCI system which may have a CommSlot2 Ethernet card");
  338.             fprintf(stdout, "\nmust use Open Transport to obtain the ethernet address");
  339.             break;
  340.         
  341.         default:
  342.             fprintf(stdout, "\n It appears that this CPU does not have built-in ethernet\n");
  343.             break;
  344.     }
  345. }
  346.  
  347. void DisplayOTEthernetAddresses(void)
  348. {
  349.     OSStatus         status;
  350.     EndpointRef        ep;
  351.     OTPortRecord    devicePortRecord;
  352.     UInt32            index;
  353.     TBind            returnInfo;
  354.     TBind            requestInfo;
  355.     Address8022     theReturnAddr =     {AF_8022, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x0000,
  356.                                         {0x00,0x00,0x00,0x00,0x00}};
  357.     Address8022     theAddr =     {AF_8022, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x8888,
  358.                                     {0x00,0x00,0x00,0x00,0x00}};
  359.     Boolean            foundAPort;
  360.     Str255            userFriendlyName;
  361.     
  362.     
  363.     if (status = InitOpenTransport())
  364.     {
  365.         fprintf(stdout, "\n\nOpen Transport is not installed or is inactive\n");
  366.         return;
  367.     }
  368.     else
  369.     {
  370.         fprintf(stdout, "\n\nNow checking for Ethernet addresses using Open Transport\n");
  371.         fprintf(stdout, "There will be a slight delay as I try to open a connection\n");
  372.         fprintf(stdout, "over each card.\n");
  373.     }
  374.  
  375.     index = 0;
  376.         // iterate thru each OT port record for ethernet ports.    
  377.     while (foundAPort = OTGetIndexedPort(&devicePortRecord,index))
  378.     {
  379.         if ((devicePortRecord.fCapabilities & kOTPortIsDLPI) &&
  380.             (devicePortRecord.fCapabilities & kOTPortIsTPI) &&
  381.             (kOTEthernetDevice == OTGetDeviceTypeFromPortRef(devicePortRecord.fRef)))
  382.         {
  383.     
  384.             ep = OTOpenEndpoint(OTCreateConfiguration(devicePortRecord.fPortName), (OTOpenFlags)NULL, NULL,&status);
  385.     
  386.             if (status == kOTNoError)
  387.             {
  388.                     // we have to bind the endpoint before we can get it's address info
  389.                 requestInfo.addr.buf = (UInt8 *)&theAddr;
  390.                 requestInfo.addr.len = 10;    // family type + Ethernet + type field
  391.                                 // don't use sizeof(theAddr) since we are binding to type 1 Ethernet
  392.                                 // address, not to an 802.2 address.
  393.                 requestInfo.addr.maxlen = 0;            
  394.                 requestInfo.qlen = 0;
  395.     
  396.                 status = OTBind(ep, &requestInfo, NULL);
  397.  
  398.                 if (status == kOTNoError)
  399.                 {
  400.                     returnInfo.addr.buf = (UInt8 *)&theReturnAddr;
  401.                     returnInfo.addr.maxlen = 10;            // family type + 6 bytes for Ethernet + type
  402.                     returnInfo.qlen = 0;
  403.                     
  404.                     
  405.                     status = OTGetProtAddress(ep,&returnInfo,NULL);
  406.                     
  407.                     if (status == kOTNoError)
  408.                     {
  409.                         OTGetUserPortNameFromPortRef(devicePortRecord.fRef, userFriendlyName);
  410.                         fprintf(stdout, "\n   The Ethernet address for %#s is => ", userFriendlyName);
  411.                         DisplayEnetAddr((UInt8*)&theReturnAddr.fHWAddr);
  412.                     }
  413.                     OTUnbind(ep);
  414.                 }
  415.                 
  416.                 OTCloseProvider(ep);
  417.             }    
  418.                 
  419.                 
  420.         }
  421.         index++;
  422.     }    
  423.     
  424.     
  425.     
  426.         // closing down
  427.     CloseOpenTransport();
  428.     
  429.     
  430. }
  431.  
  432. main (void)
  433. {
  434.     
  435.     fprintf(stdout, "Sample program to obtain the available ethernet addresses");
  436.     DisplayBurnedInAddress();
  437.     
  438.     DisplayOTEthernetAddresses();
  439.     return 0;
  440. }
  441.